{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.3 常用操作\n",
    "在进行图像卷积操作时，有一些常用的操作需要讲解它们的原理和代码实现。本节我们将具体介绍填充、步长、多通道处理等问题。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.3.1 填充\n",
    "\n",
    "想必你已经观察到如果卷积核和输入图像尺寸不同，输出图像的大小就不能与输入图像保持一致了。为了解决这个问题，人们想出了很简单但是实用的办法，就是填充（padding）操作。\n",
    "\n",
    "在卷积运算时，卷积核会在图像上滑动，并对图像的每个子区域进行卷积运算。例如，假设我们有一个 3x3 的输入图像，并使用一个 3x3 的卷积核。在进行卷积运算时，我们会把卷积核的中心对齐到输入图像的左上角，然后对输入图像的这个子区域进行卷积运算。然后我们会把卷积核向右移一个像素，并对输入图像的下一个子区域进行卷积运算。如此重复，直到我们对整个输入图像进行了卷积运算。但是，在进行卷积运算时，边缘像素会被忽略。例如，在上面的例子中，卷积核的左上角会对输入图像的左上角进行卷积运算，但卷积核的右上角和左下角将不会参与卷积运算。这意味着输入图像的边缘像素将不会参与卷积运算，并可能丢失重要信息。\n",
    "\n",
    "为了解决这个问题，我们可以使用 padding。padding 指的是在输入图像周围填充一圈零值像素。这样，卷积核就可以对输入图像的所有像素进行卷积运算，而不会忽略边缘像素。例如，假设我们使用了一个 3x3 的卷积核和 1 像素的 padding。我们的输入图像是 3x3 的，但实际上我们使用的是一个 5x5 的图像，其中边缘像素都被填充为 0。这样，卷积核就可以对输入图像的所有像素进行卷积运算，而不会忽略边缘像素。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[[[25]]]])\n",
      "tensor([[[[ 7, 11, 11],\n",
      "          [17, 25, 23],\n",
      "          [19, 29, 23]]]])\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "# 创建输入图像\n",
    "input_image = torch.tensor([[1, 2, 3],\n",
    "                            [4, 5, 6],\n",
    "                            [7, 8, 9]])\n",
    "\n",
    "# 创建卷积核\n",
    "kernel = torch.tensor([[0, 1, 0],\n",
    "                       [1, 1, 1],\n",
    "                       [0, 1, 0]])\n",
    "\n",
    "# 使用默认的 padding (padding=0) 进行卷积运算\n",
    "output_image = torch.conv2d(input_image.unsqueeze(0).unsqueeze(0), kernel.unsqueeze(0).unsqueeze(0))\n",
    "print(output_image)  # 输出: tensor([[[[25]]]])\n",
    "\n",
    "# 使用 padding=1 进行卷积运算\n",
    "output_image_padded = torch.conv2d(input_image.unsqueeze(0).unsqueeze(0), kernel.unsqueeze(0).unsqueeze(0), padding=1)\n",
    "print(output_image_padded)  # 输出: tensor([[[[ 7, 11, 11],\n",
    "                            #  [17, 25, 23],\n",
    "                            #  [19, 29, 23]]]])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在这个示例中，我们使用了一个 3x3 的输入图像和一个 3x3 的卷积核。默认的 padding 是 0，因此我们的输出图像是 1x1 的。但是，如果我们使用 padding=1，则输出图像将是 3x3 的，因为我们在输入图像周围填充了一圈 0 像素。你可以看到，使用 padding 后输出图像更大，并且边缘像素也参与了卷积运算。这就是使用 padding 的好处。\n",
    "\n",
    "#### 使用填充时的注意事项：\n",
    "\n",
    "* 在使用 padding 时，你需要确定 padding 的大小。一般来说，padding 的大小应该是卷积核的大小的一半。例如，如果卷积核的大小是 3x3，则 padding 的大小应该是 1。这样，卷积核就可以对输入图像的所有像素进行卷积运算，而不会忽略边缘像素。\n",
    "\n",
    "* 在使用 padding 时，输入图像的大小会变大。这可能会导致模型的计算量增加，并可能需要更多的存储空间。因此，你需要考虑是否真的需要使用 padding，或者是否可以使用更小的 padding 大小。\n",
    "\n",
    "* 在使用 padding 时，输出图像的大小也会变大。这可能会导致模型的计算量增加，并可能需要更多的存储空间。因此，你需要考虑是否真的需要使用 padding，或者是否可以使用更小的 padding 大小。\n",
    "\n",
    "* 在使用 padding 时，你可能需要使用更多的卷积层来捕捉更多的特征。因为使用 padding 后输入图像的大小会变大，所以你可能需要使用更多的卷积层来提取图像的特征。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.3.2 步长\n",
    "在卷积神经网络 (CNN) 中，步长（stride）是指卷积核在输入图像上滑动的步长。例如，假设我们有一个 3x3 的输入图像，并使用一个 3x3 的卷积核。在进行卷积运算时，我们会把卷积核的中心对齐到输入图像的左上角，然后对输入图像的这个子区域进行卷积运算。然后我们会把卷积核向右移一个像素，并对输入图像的下一个子区域进行卷积运算。如此重复，直到我们对整个输入图像进行了卷积运算。\n",
    "\n",
    "我们可以通过调整步长来改变卷积核在输入图像上滑动的距离。例如，如果步长是 2，则卷积核会每次向右移动 2 个像素。这会导致卷积核对输入图像进行卷积运算的次数减少，但同时也会导致输出图像的大小减小。通常来说，步长的值为 1 或 2。当步长为 1 时，卷积核会在输入图像上滑动一个像素。当步长为 2 时，卷积核会在输入图像上滑动两个像素。使用较大的步长可以减少卷积运算的次数，并减少输出图像的大小。这可以降低计算量，但同时也可能导致信息丢失。因此，在选择步长时，需要权衡计算量和信息损失的问题。\n",
    "\n",
    "此外，步长还可以用于控制卷积核的步长在输入图像的哪一维方向滑动。例如，假设我们有一个 4x4 的输入图像和一个 3x3 的卷积核。如果我们设置步长为 (1, 2)，则卷积核会在输入图像的行方向滑动 1 个像素，在列方向滑动 2 个像素。这样，卷积核会对输入图像进行 4 次卷积运算，并产生一个 2x2 的输出图像。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output image with stride=1:\n",
      "tensor([[[[ 8, 12, 16, 15],\n",
      "          [21, 30, 35, 31],\n",
      "          [37, 50, 55, 47],\n",
      "          [36, 52, 56, 43]]]])\n",
      "Output image with stride=2:\n",
      "tensor([[[[ 8, 16],\n",
      "          [37, 55]]]])\n",
      "Output image with stride=3:\n",
      "tensor([[[[30]]]])\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "# 创建输入图像\n",
    "input_image = torch.tensor([[1, 2, 3, 4],\n",
    "                            [5, 6, 7, 8],\n",
    "                            [9, 10, 11, 12],\n",
    "                            [13, 14, 15, 16]])\n",
    "\n",
    "# 创建卷积核\n",
    "kernel = torch.tensor([[0, 1, 0],\n",
    "                       [1, 1, 1],\n",
    "                       [0, 1, 0]])\n",
    "\n",
    "# 使用步长为 1 进行卷积运算\n",
    "output_image = torch.conv2d(input_image.unsqueeze(0).unsqueeze(0), kernel.unsqueeze(0).unsqueeze(0), stride=1, padding=1)\n",
    "print(\"Output image with stride=1:\")\n",
    "print(output_image) \n",
    "\n",
    "# 使用步长为 2 进行卷积运算\n",
    "output_image_strided = torch.conv2d(input_image.unsqueeze(0).unsqueeze(0), kernel.unsqueeze(0).unsqueeze(0), stride=2,padding=1)\n",
    "print(\"Output image with stride=2:\")\n",
    "print(output_image_strided)  \n",
    "\n",
    "# 使用步长为 3 进行卷积运算\n",
    "output_image_strided = torch.conv2d(input_image.unsqueeze(0).unsqueeze(0), kernel.unsqueeze(0).unsqueeze(0), stride=3)\n",
    "print(\"Output image with stride=3:\")\n",
    "print(output_image_strided)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.3.3 多通道处理\n",
    "\n",
    "面对复杂一点拥有多个通道的彩色图像，在进行卷积操作时面临如何处理这多个通道的问题。具体怎么办呢？这主要取决于使用的卷积方式。通常来说，我们有两种卷积方式可以用于处理多个通道的图像：\n",
    "\n",
    "#### 分组卷积\n",
    "\n",
    "在分组卷积中，我们将输入图像的通道划分成若干组，每组中的通道使用相同的卷积核进行卷积。例如，假设我们有一个三维输入图像 $\\mathbf{X}\\in\\mathbb{R}^{H\\times W\\times C}$，其中 $C$ 表示通道数。我们使用的卷积核是一个四维张量 $\\mathbf{W}\\in\\mathbb{R}^{k_h\\times k_w\\times C\\times K}$，其中 $K$ 表示输出通道数。在使用全连接卷积时，卷积层包含的参数数量为 $k_hk_wCK$，而在使用分组卷积时，可以将输入图像的通道划分成 $G$ 组，每组包含 $C/G$ 个通道，这样卷积层包含的参数数量就变为 $k_hk_w(C/G)K$。当 $G>1$ 时，卷积层包含的参数数量就会减少。\n",
    "\n",
    "#### 全连接卷积\n",
    "\n",
    "在全连接卷积中，我们对输入图像的每一个通道分别使用不同的卷积核进行卷积。例如，假设我们有一个三维输入图像 $\\mathbf{X}\\in\\mathbb{R}^{H\\times W\\times C}$，其中 $C$ 表示通道数。我们使用的卷积核是一个四维张量 $\\mathbf{W}\\in\\mathbb{R}^{k_h\\times k_w\\times C\\times K}$，其中 $K$ 表示输出通道数。在全连接卷积中，我们对输入图像的每一个通道分别使用不同的卷积核进行卷积，得到 $C$ 个二维输出图像 $\\mathbf{Y}_1, \\mathbf{Y}_2, \\dots, \\mathbf{Y}_C$。然后，我们将这 $C$ 个二维输出图像在通道维度上拼接在一起，得到最终的三维输出图像 $\\mathbf{Y}\\in\\mathbb{R}^{H\\times W\\times K}$。\n",
    "\n",
    "不仅输入图像可以是多通道的，输出图像也可以有。在卷积神经网络 (CNN) 中，输出通道是指卷积层输出的图像的数量。例如，如果卷积层的输出通道数为 16，则会产生 16 个输出图像，每个图像都是独立的。\n",
    "\n",
    "使用多个输出通道可以增强 CNN 的能力，因为它可以捕捉不同的特征。例如，在图像分类任务中，卷积层的某些输出通道可能会捕捉边缘特征，而其他通道可能会捕捉颜色特征。举个例子，假设我们正在对一张包含猫的图像进行分类。在这种情况下，卷积层的某些输出通道可能会捕捉到图像中猫的轮廓线，而其他通道可能会捕捉到猫的毛发颜色。这样，CNN 就可以利用这些信息来判断图像中是否存在猫。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import os\n",
    "os.environ[\"KMP_DUPLICATE_LIB_OK\"] = \"TRUE\"\n",
    "\n",
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# 加载图像\n",
    "from skimage import io\n",
    "image = io.imread(\"../images/732.jpg\")\n",
    "\n",
    "# 将图像转换为 PyTorch 张量\n",
    "image = torch.tensor(image).float()\n",
    "\n",
    "# 将图像的通道数转换为单通道\n",
    "image = image.mean(dim=2)\n",
    "\n",
    "# 添加批量维度\n",
    "image = image.unsqueeze(0).unsqueeze(0)\n",
    "\n",
    "# 创建卷积层，输出通道数为 3\n",
    "conv = torch.nn.Conv2d(1, 3, kernel_size=3)\n",
    "\n",
    "# 对输入图像进行卷积\n",
    "output = conv(image)\n",
    "\n",
    "# 将输出转换为 NumPy 数组\n",
    "output_image = output.squeeze(0).detach().numpy()\n",
    "\n",
    "# 将输出图像的 3 个通道可视化\n",
    "plt.subplot(1, 3, 1)\n",
    "plt.imshow(output_image[0], cmap='gray')\n",
    "plt.title(\"Output channel 1\")\n",
    "plt.subplot(1, 3, 2)\n",
    "plt.imshow(output_image[1], cmap='gray')\n",
    "plt.title(\"Output channel 2\")\n",
    "plt.subplot(1, 3, 3)\n",
    "plt.imshow(output_image[2], cmap='gray')\n",
    "plt.title(\"Output channel 3\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Next 7-4 池化层](./7-4%20池化层.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
